// pages/gallery/gallery.js
const galleryApi = require('../../api/galleryApi');

Page({

  /**
   * 页面的初始数据
   */
  data: {
    images: [],
    loading: false,
    currentPage: 1,
    pageSize: 10,
    hasMore: true,
    viewMode: 'grid', // 'grid' 或 'fullscreen'
    currentImageIndex: 0 // 当前查看的图片索引
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    this.loadImages();
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 从全局数据或缓存中获取更新标志
    const app = getApp();
    const needRefresh = app.globalData.galleryNeedRefresh || 
                       wx.getStorageSync('galleryNeedRefresh');
    
    // 如果需要刷新，则重新加载画廊数据
    if (needRefresh) {
      console.log('画廊页面需要刷新');
      
      // 重置数据
      this.setData({
        images: [],
        currentPage: 1,
        hasMore: true
      });
      
      // 重新加载数据
      this.loadImages();
      
      // 重置更新标志
      app.globalData.galleryNeedRefresh = false;
      wx.removeStorageSync('galleryNeedRefresh');
    }
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    this.setData({
      images: [],
      currentPage: 1,
      hasMore: true
    });
    this.loadImages();
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    if (this.data.hasMore && !this.data.loading && this.data.viewMode !== 'fullscreen') {
      this.loadMoreImages();
    }
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    return {
      title: '发现精彩AI图像创作',
      path: '/pages/gallery/gallery'
    };
  },

  // 加载图片
  loadImages: function() {
    if (this.data.loading) return;
    
    this.setData({ loading: true });
    
    // 使用galleryApi调用获取真实数据
    galleryApi.getGalleryList({
      page: 1,
      limit: this.data.pageSize,
      sortBy: 'createTime'
    }).then(result => {
      console.log('获取图片列表成功:', result);
      
      // 处理返回的图片数据
      const images = this.processImageData(result.data.images);
      
      this.setData({
        images: images,
        currentPage: 1,
        hasMore: result.data.hasMore,
        loading: false
      });
      
      // 检查处理后的图片是否有URL
      if (images.length > 0) {
        console.log('首张处理后图片:', images[0]);
      }
      
      // 隐藏所有加载提示
      wx.hideLoading();
      wx.stopPullDownRefresh();
    }).catch(err => {
      console.error('获取图片列表失败:', err);
      this.setData({ loading: false });
      
      wx.showToast({
        title: '获取图片失败',
        icon: 'none'
      });
      
      // 隐藏所有加载提示
      wx.hideLoading();
      wx.stopPullDownRefresh();
    });
  },

  // 加载更多图片
  loadMoreImages: function() {
    if (!this.data.hasMore || this.data.loading) return;
    
    this.setData({ loading: true });
    const nextPage = this.data.currentPage + 1;
    
    // 显示加载提示
    wx.showLoading({
      title: '加载更多...',
      mask: true
    });
    
    // 使用galleryApi调用获取更多真实数据
    galleryApi.getGalleryList({
      page: nextPage,
      limit: this.data.pageSize,
      sortBy: 'createTime'
    }).then(result => {
      console.log('获取更多图片成功:', result);
      
      // 处理返回的图片数据
      const newImages = this.processImageData(result.data.images);
      
      this.setData({
        images: [...this.data.images, ...newImages],
        currentPage: nextPage,
        hasMore: result.data.hasMore,
        loading: false
      });
      
      // 隐藏加载提示
      wx.hideLoading();
    }).catch(err => {
      console.error('获取更多图片失败:', err);
      this.setData({ loading: false });
      
      wx.showToast({
        title: '获取更多图片失败',
        icon: 'none'
      });
      
      // 隐藏加载提示
      wx.hideLoading();
    });
  },

  // 处理图片数据
  processImageData: function(images) {
    if (!images || !Array.isArray(images)) {
      console.error('processImageData: 无效的图片数据', images);
      return [];
    }
    
    return images.map(image => {
      // 确保有有效ID
      const id = image._id || image.id || '';
      
      // 尝试从多个可能的字段获取图片URL
      let imageUrl = '';
      
      // 检查所有可能的图片URL字段
      if (image.fileID) {
        imageUrl = image.fileID;
      } else if (image.file && image.file.url) {
        imageUrl = image.file.url;
      } else if (image.file) {
        imageUrl = image.file;
      } else if (image.imageUrl) {
        imageUrl = image.imageUrl;
      } else if (image.url) {
        imageUrl = image.url;
      } else if (image.coverUrl) {
        imageUrl = image.coverUrl;
      } else if (image.tempFileURL) {
        imageUrl = image.tempFileURL;
      } else if (image.filePath) {
        imageUrl = image.filePath;
      }
      
      // 无法获取图片URL时使用占位图
      if (!imageUrl) {
        console.warn(`无法获取图片URL，图片ID: ${id}`);
        imageUrl = '/static/images/default/placeholder.png';
      }
      
      // 提取标题，如果没有则使用默认值
      const title = image.title || '无题';
      
      // 提取作者信息
      const author = image.author || {
        nickName: '未知用户',
        avatarUrl: '/static/images/default/default-avatar.png'
      };
      
      // 提取互动信息
      const isLiked = image.isLiked || false;
      const isFavorited = image.isFavorited || false;
      const likeCount = image.likeCount || 0;
      const favoriteCount = image.favoriteCount || 0;
      const commentCount = image.commentCount || 0;
      
      // 格式化创建时间
      const createTime = image.createTime ? this.formatDate(image.createTime) : '';
      
      // 返回处理后的图片对象
      return {
        id: id,
        imageUrl: imageUrl,
        title: title,
        description: image.description || '',
        prompt: image.prompt || '',
        negativePrompt: image.negativePrompt || '',
        style: image.style || '',
        author: author,
        isLiked: isLiked,
        isFavorited: isFavorited,
        likeCount: likeCount,
        favoriteCount: favoriteCount,
        commentCount: commentCount,
        createTime: createTime,
        category: image.category || ''
      };
    });
  },

  // 格式化日期
  formatDate: function(dateStr) {
    if (!dateStr) return '';
    
    try {
      const date = new Date(dateStr);
      
      // 检查日期是否有效
      if (isNaN(date.getTime())) {
        return '';
      }
      
      const year = date.getFullYear();
      const month = String(date.getMonth() + 1).padStart(2, '0');
      const day = String(date.getDate()).padStart(2, '0');
      
      return `${year}-${month}-${day}`;
    } catch (error) {
      console.error('日期格式化失败:', error);
      return '';
    }
  },

  // 打开详情页
  goToDetail: function(e) {
    const id = e.currentTarget.dataset.id;
    wx.navigateTo({
      url: `/pages/detail/detail?id=${id}`
    });
  },

  // 打开全屏模式
  openFullscreen: function(e) {
    const index = e.currentTarget.dataset.index;
    
    this.setData({
      viewMode: 'fullscreen',
      currentImageIndex: index
    });
  },

  // 切换视图模式
  toggleViewMode: function() {
    this.setData({
      viewMode: this.data.viewMode === 'fullscreen' ? 'grid' : 'fullscreen'
    });
  },

  // 复制提示词
  copyPrompt: function(e) {
    const prompt = e.currentTarget.dataset.prompt;
    
    if (!prompt) {
      wx.showToast({
        title: '无提示词',
        icon: 'none'
      });
      return;
    }
    
    wx.setClipboardData({
      data: prompt,
      success: () => {
        wx.showToast({
          title: '提示词已复制',
          icon: 'success'
        });
      }
    });
  },
  
  // 前往创建页面
  goToCreate: function() {
    wx.navigateTo({
      url: '/pages/create/create'
    });
  },

  // 滑动切换图片
  onSwiperChange: function(e) {
    this.setData({
      currentImageIndex: e.detail.current
    });
  },

  // 点赞/取消点赞
  toggleLike: function(e) {
    const id = e.currentTarget.dataset.id;
    const images = [...this.data.images];
    const index = images.findIndex(item => item.id === id);
    
    if (index === -1) return;
    
    const isLiked = !images[index].isLiked;
    const likeCount = isLiked ? images[index].likeCount + 1 : images[index].likeCount - 1;
    
    images[index] = {
      ...images[index],
      isLiked,
      likeCount: likeCount < 0 ? 0 : likeCount
    };
    
    this.setData({ images });
    
    // 调用云函数点赞/取消点赞
    wx.cloud.callFunction({
      name: 'gallery',
      config: {
        env: wx.cloud.DYNAMIC_CURRENT_ENV
      },
      data: {
        action: isLiked ? 'likeImage' : 'unlikeImage',
        params: {
          imageId: id
        }
      },
      success: res => {
        console.log('点赞操作成功:', res.result);
        
        if (!res.result || !res.result.success) {
          // 操作失败，恢复状态
          images[index] = {
            ...images[index],
            isLiked: !isLiked,
            likeCount: isLiked ? likeCount - 1 : likeCount + 1
          };
          this.setData({ images });
          
          wx.showToast({
            title: '操作失败',
            icon: 'none'
          });
        } else {
          // 操作成功，设置刷新标志以确保所有页面状态一致
          const app = getApp();
          app.globalData.galleryNeedRefresh = true;
          
          // 设置个人页面统计数据需要更新的标志
          app.globalData.userStatsNeedRefresh = true;
          wx.setStorageSync('userStatsNeedRefresh', true);
        }
      },
      fail: err => {
        console.error('调用云函数失败:', err);
        // 操作失败，恢复状态
        images[index] = {
          ...images[index],
          isLiked: !isLiked,
          likeCount: isLiked ? likeCount - 1 : likeCount + 1
        };
        this.setData({ images });
        
        wx.showToast({
          title: '操作失败',
          icon: 'none'
        });
      }
    });
  },

  // 收藏/取消收藏
  toggleFavorite: function(e) {
    const id = e.currentTarget.dataset.id;
    const images = [...this.data.images];
    const index = images.findIndex(item => item.id === id);
    
    if (index === -1) {
      console.error('找不到图片:', id);
      wx.showToast({
        title: '操作失败，找不到图片',
        icon: 'none'
      });
      return;
    }
    
    const isFavorited = !images[index].isFavorited;
    const favoriteCount = isFavorited ? images[index].favoriteCount + 1 : images[index].favoriteCount - 1;
    
    // 添加调试信息
    console.log('收藏操作：', {
      imageId: id,
      isFavorited: isFavorited,
      currentCount: images[index].favoriteCount,
      newCount: favoriteCount
    });
    
    images[index] = {
      ...images[index],
      isFavorited,
      favoriteCount: favoriteCount < 0 ? 0 : favoriteCount
    };
    
    this.setData({ images });
    
    // 显示加载提示
    wx.showLoading({
      title: isFavorited ? '收藏中...' : '取消收藏中...',
      mask: true
    });
    
    // 调用云函数收藏/取消收藏
    wx.cloud.callFunction({
      name: 'gallery',
      config: {
        env: wx.cloud.DYNAMIC_CURRENT_ENV
      },
      data: {
        action: 'favoriteImage',
        params: {
          imageId: id // 确保这里传递的是一个有效的ID
        }
      },
      success: res => {
        // 隐藏加载提示
        wx.hideLoading();
        
        console.log('收藏操作响应:', res.result);
        
        if (!res.result || !res.result.success) {
          // 操作失败，恢复状态
          images[index] = {
            ...images[index],
            isFavorited: !isFavorited,
            favoriteCount: isFavorited ? favoriteCount - 1 : favoriteCount + 1
          };
          this.setData({ images });
          
          // 显示详细的错误信息
          wx.showToast({
            title: res.result ? res.result.message || '操作失败' : '操作失败',
            icon: 'none'
          });
        } else {
          // 操作成功，设置刷新标志以确保所有页面状态一致
          const app = getApp();
          app.globalData.galleryNeedRefresh = true;
          
          // 设置个人页面统计数据需要更新的标志
          app.globalData.userStatsNeedRefresh = true;
          wx.setStorageSync('userStatsNeedRefresh', true);
          
          // 显示成功提示
          wx.showToast({
            title: isFavorited ? '收藏成功' : '已取消收藏',
            icon: 'success'
          });
        }
      },
      fail: err => {
        // 隐藏加载提示
        wx.hideLoading();
        
        console.error('调用云函数失败:', err);
        // 操作失败，恢复状态
        images[index] = {
          ...images[index],
          isFavorited: !isFavorited,
          favoriteCount: isFavorited ? favoriteCount - 1 : favoriteCount + 1
        };
        this.setData({ images });
        
        wx.showToast({
          title: '操作失败',
          icon: 'none'
        });
      }
    });
  },

  // 下载图片
  downloadImage: function(e) {
    const url = e.currentTarget.dataset.url;
    
    if (!url) {
      wx.showToast({
        title: '图片地址不存在',
        icon: 'none'
      });
      return;
    }
    
    console.log('下载图片地址:', url);
    
    wx.showLoading({
      title: '下载中...',
      mask: true
    });
    
    // 根据URL类型处理下载
    if (url.startsWith('cloud://') || url.startsWith('cloud-')) {
      // 云存储文件
      wx.cloud.downloadFile({
        fileID: url,
        success: res => {
          wx.hideLoading();
          const tempFilePath = res.tempFilePath;
          this.saveToAlbum(tempFilePath);
        },
        fail: err => {
          wx.hideLoading();
          console.error('下载云文件失败:', err);
          wx.showToast({
            title: '下载失败',
            icon: 'none'
          });
        }
      });
    } else {
      // 普通URL下载
      wx.downloadFile({
        url: url,
        success: res => {
          wx.hideLoading();
          if (res.statusCode === 200) {
            const tempFilePath = res.tempFilePath;
            this.saveToAlbum(tempFilePath);
          } else {
            wx.showToast({
              title: '下载失败',
              icon: 'none'
            });
          }
        },
        fail: err => {
          wx.hideLoading();
          console.error('下载图片失败:', err);
          wx.showToast({
            title: '下载失败',
            icon: 'none'
          });
        }
      });
    }
  },
  
  // 保存到相册
  saveToAlbum: function(filePath) {
    wx.saveImageToPhotosAlbum({
      filePath: filePath,
      success: () => {
        wx.showToast({
          title: '保存成功',
          icon: 'success'
        });
      },
      fail: err => {
        console.error('保存图片失败:', err);
        wx.showToast({
          title: '保存失败',
          icon: 'none'
        });
      }
    });
  },

  // 长按图片操作
  onImageLongPress: function(e) {
    const id = e.currentTarget.dataset.id;
    const index = this.data.images.findIndex(item => item.id === id);
    
    if (index === -1) return;
    
    const image = this.data.images[index];
    
    wx.showActionSheet({
      itemList: ['查看详情', '保存到相册', '分享', image.isLiked ? '取消点赞' : '点赞', image.isFavorited ? '取消收藏' : '收藏'],
      success: (res) => {
        switch (res.tapIndex) {
          case 0:
            this.goToDetail({ currentTarget: { dataset: { id } } });
            break;
          case 1:
            this.downloadImage({ currentTarget: { dataset: { url: image.imageUrl } } });
            break;
          case 2:
            wx.showShareMenu({
              withShareTicket: true,
              menus: ['shareAppMessage', 'shareTimeline']
            });
            break;
          case 3:
            this.toggleLike({ currentTarget: { dataset: { id } } });
            break;
          case 4:
            this.toggleFavorite({ currentTarget: { dataset: { id } } });
            break;
        }
      }
    });
  },

  // 图片加载成功回调
  onImageLoad: function(e) {
    console.log('图片加载成功:', e);
  },

  // 图片加载失败回调
  onImageError: function(e) {
    console.error('图片加载失败:', e);
    const index = e.currentTarget.dataset.index;
    if (index !== undefined) {
      const images = this.data.images;
      if (images[index]) {
        // 尝试使用备用图片URL
        const newImages = [...images];
        if (newImages[index].imageUrl !== '/static/images/default/placeholder.png') {
          console.log(`将图片${index}更换为默认图片`);
          newImages[index] = {
            ...newImages[index],
            imageUrl: '/static/images/default/placeholder.png'
          };
          this.setData({ images: newImages });
        }
      }
    }
  },

  // 分析图片结构
  analyzeImageStructure: function(image) {
    console.log('===== 图片结构分析 =====');
    console.log('图片完整数据:', image);
    
    // 列出所有顶级字段
    console.log('顶级字段:');
    Object.keys(image).forEach(key => {
      const value = image[key];
      const type = typeof value;
      console.log(`- ${key} (${type}): ${type === 'object' ? '对象' : value}`);
      
      // 如果是对象，展开其内部字段
      if (type === 'object' && value !== null) {
        Object.keys(value).forEach(subKey => {
          console.log(`  - ${key}.${subKey}: ${value[subKey]}`);
        });
      }
      
      // 检查特殊字段
      if (key.toLowerCase().includes('url') || key.toLowerCase().includes('file') || 
          key.toLowerCase().includes('image') || key.toLowerCase().includes('path')) {
        console.log(`潜在图片URL字段: ${key} = ${value}`);
      }
    });
    
    console.log('========================');
  },
});